//数据类型与变量
public class Main {

    /**
     * String类型
     * @param args
     * 字符串拼接: 可以将字符串和任何类型拼接成一个新的字符串
     */
    public static void main(String[] args) {
        //字符串定义及初始化
        String str1 = "123";
        System.out.println(str1);

        //字符串拼接
        String str2 = "456";
        System.out.println(str1 + str2);

       int a  = 10;
       System.out.println("a == " + 10);

        int b = 20;
        System.out.println("a + b == " + a + b);//1020
        System.out.println(a + b + "== a + b");//从左向右进行拼接,也可能是进行相加
        //字符串转换
        //字符串类型转换为整数: Integer.parseInt(字符串)
        System.out.println(Integer.parseInt(str1) + 1);

        //类型转为字符串类型(以int类型为例子,其他类型均适用)
        //1.方法一,类型+ ""
        System.out.println(a + "");
        //2.方法二,String.valueOf(类型)
        System.out.println(String.valueOf(a));
        //3.方法三,Integer.toString(类型)
        System.out.println(Integer.toString(a));
    }

    /**
     * 类型提升: 进行运算时
     * 1.运算时,小类型会先提升为大类型再进行运算
     * 2.小于int类型变量进行运算时,会先将小类型均提升为int类型再进行计算
     * 原因:CPU存储时,都是以4个字节为单位从内存中读取数据,提升为int类型可以方便读取
     */
    public static void main12(String[] args) {

        int a = 10;
        long b = 20;
        System.out.println(a + b);

        byte c = 10;
        byte d = 20;
        //byte e = c + d;.//error
        int e = c + d;
        System.out.println(e);
    }

    /**
     * 类型转换 隐式类型提升 显示类型提升(强制类型转换)
     */
    public static void main11(String[] args) {
        /**
         * 显示类型转换(强制类型转换): 大类型变量转为小类型变量,需要对大类型变量进行强制类型转换(小类型)大类型变量
         * 注:可能会发生截断,导致数值改变
         */
        int a = 10;
        long b = 20;
        a = (int)b;
        System.out.println(a);

        float c = 1.12f;
        double d = 10.0;
        c = (float)d;
        System.out.println(c);
    }
    public static void main10(String[] args) {
        /**
         * 隐式类型提升: 将小类型变量赋值给大类型变量时,会自动将小类型变量类型提升为大类型变量
         */
        int a = 10;
        long b = 20;
        b = a;
        System.out.println(b);

        float c = 12.1f;
        double d = 20.0;
        d = c;
        System.out.println(d);
    }

    /**
     * 变量:程序运行过程中,可以进行修改的值
     * @param args
     * 语法个数: 数据类型 变量名 = 初始值;
     * 变量范围: -2^数据类型字节个数 - (2^数据类型个数) -1
     * 注: 1.变量必须在使用之前进行赋值
     * 2.变量不能够超出变量范围
     * 3.可移植性强,无论在什么系统下,类型的字节个数不变
     * 4. 任何类型都是带符号的
     */

    /**
     * 布尔类型 boolean
     */
    public static void main9(String[] args) {
        /**
         * boolean
         * 范围 java虚拟机中没有明确指定boolean的大小,，在Oracle公司的虚拟机实现中，boolean占1个字节
         * 包装类型 Boolean
         * 只有两个取值 true false,不存在0和非零的讲法
         */
        boolean flag1 = true;
        boolean flag2 = false;
        System.out.println(flag1);
        System.out.println(flag2);
    }

    /**
     * 字符类型 char
     * 表示范围符合 unicode字符集
     */
    public static void main8(String[] args) {
        /**
         * 字符型类型 char
         * 范围 0 - (2 ^ 7) - 1
         * 任何系统下都是2个字节
         * 包装类型 Character
         */
        char ch1 = 'a';
        char ch2 = '帅';
        System.out.println(ch1);
        System.out.println(ch2);
        System.out.println((int)Character.MAX_VALUE);
        System.out.println((int)Character.MIN_VALUE);
    }

    /**
     * 浮点数类型 float double
     * @param args
     * 范围一般不关注
     * 进行浮点数运算时,结果不一定是准确的,一般都是在一个范围内或取前面几位是准确的
     */
    public static void main7(String[] args) {
        /**
         * 单精度浮点数类型 float
         * 任何系统下 4个字节
         * 一般情况下,浮点数类型默认为double,所以定义flaot变量类型时,需要加f/F
         * 包装类型 Float
         */
        float  f = 1.14f;
        System.out.println(f);

        /**
         * 双精度浮点数 double
         * 任何系统下 8个字节
         * 包装类型 Double
         */
        double d = 1.1;
        System.out.println(d);

        System.out.println(d * d);
    }
    /**
     * 整数类型: byte short int long
     * @param args
     * 为什么要有多个不同整数类型?
     * 例如衣服尺码,要求(情况)不同选择不同,不同类型范围不同,可以根据不同的要求进行选择便于书写代码
     */

    public static void main6(String[] args) {
        /**
         * byte类型
         * 范围 -2^7 - (2 ^ 7) - 1
         * 任何系统下都是1字节
         * 包装类型为Byte
         */
        byte a = 10;
        System.out.println(a);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);
    }
    public static void main5(String[] args) {
        /**
         * short类型
         * 范围 -2^15 - (2^15) - 1
         * 任何系统下都是2字节
         * 包装类型为 Short
         */
        short a = 10;
        System.out.println(a);
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);
    }

    public static void main4(String[] args) {
        /**
         * long类型
         * 范围 -2^63 - (2^63) -1
         * 任何系统下,long类型都是8字节
         * 使用long进行定义变量时,值后面加L
         * 包装类型 Long
         */
        long a = 10L;
        System.out.println(a);
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }

    public static void main3(String[] args) {
        /**
         * int类型
         * 类型范围 -2^31 - (2^31)-1
         * 任何系统下 都只占4个字节
         * 包装类型为 Integer
         *
         */
        int a = 10;
        System.out.println(a);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }
    //数据类型
    public static void main2(String[] args) {
        //基本数据类型/内置数据类型
        //1.整数类型: byte short int long
        //2.浮点类型: float double
        //3.字符类型: char
        //4.布尔类型: boolean

        //引用数据类型: 创建的变量都是进行存储地址的
        //string 数组....
    }
    //常量:不可修改的值
    public static void main1(String[] args) {
        System.out.println("hello");
        System.out.println(19);
        System.out.println('a');
        System.out.println(true);
        System.out.println(false);
    }
}
